package jwcb.hire.admin.server.dictionary.controller;

import jwcb.hire.admin.api.config.domain.dto.*;
import jwcb.hire.admin.api.config.domain.vo.DictionaryDataVo;
import jwcb.hire.admin.api.config.domain.vo.DictionaryTypeVO;
import jwcb.hire.admin.api.config.frign.DictionaryFeignClient;
import jwcb.hire.admin.server.dictionary.domain.dto.SysDictionaryDataDto;
import jwcb.hire.admin.server.dictionary.domain.dto.SysDictionaryTypeDto;
import jwcb.hire.admin.server.dictionary.service.ISysDictionaryService;
import jwcb.hire.common.core.utils.BeanCopyUtil;
import jwcb.hire.common.domain.domain.R;
import jwcb.hire.common.domain.domain.vo.BasePageVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Slf4j
@RestController
public class DictionaryController implements DictionaryFeignClient{



    @Autowired
    private ISysDictionaryService dictionaryService;
    /**
     * 新增字典类型
     * @param dictionaryTypeWriteReqDTO 新增数据
     * @return Id
     */
    @PostMapping("/dictionary_type/add")
    public R<Long> addDictionaryType(@RequestBody @Validated DictionaryTypeWriteReqDTO dictionaryTypeWriteReqDTO) {
        Long id = dictionaryService.addDictionaryType(dictionaryTypeWriteReqDTO);
        return R.ok(id);
    }


    /**
     * 字典类型列表查询
     * @param dictionaryTypeListReqDto 查询信息
     * @return 查询结果
     */
    @PostMapping("/dictionary_type/list")
    public R<BasePageVO<DictionaryTypeVO>> listType(@RequestBody @Validated DictionaryTypeListReqDto dictionaryTypeListReqDto) {
        BasePageVO<SysDictionaryTypeDto> serviceRet = dictionaryService.listType(dictionaryTypeListReqDto);
        BasePageVO<DictionaryTypeVO> result = new BasePageVO<>();
        BeanCopyUtil.copyProperties(serviceRet,result);
        return R.ok(result);
    }


    /**
     * 编辑字典类型
     * @param dictionaryTypeWriteReqDTO 编辑信息
     * @return 主键ID
     */
    @PostMapping("/dictionary_type/edit")
    public R<Long> editDictionaryType(@RequestBody @Validated DictionaryTypeWriteReqDTO dictionaryTypeWriteReqDTO) {
        Long id = dictionaryService.editType(dictionaryTypeWriteReqDTO);
        return R.ok(id);
    }


    /**
     * 新增字典数据
     * @param dictionaryDataAddReqDTO 新增字典数据DTO
     * @return Long
     */
    @PostMapping("/dictionary_data/add")
    public R<Long> addData(@RequestBody @Validated DictionaryDataAddReqDTO dictionaryDataAddReqDTO) {
        return R.ok(dictionaryService.addData(dictionaryDataAddReqDTO));
    }


    /**
     * 根据字典类型和值查询字典数据
     * @param dictionaryDataListReqDTO 查询信息
     * @return 查询结果
     */
    @PostMapping("/dictionary_data/list")
    public R<BasePageVO<DictionaryDataVo>> getDirectoryDataList(@RequestBody @Validated DictionaryDataListReqDTO dictionaryDataListReqDTO) {
        BasePageVO<SysDictionaryDataDto> serviceRes = dictionaryService.getDirectoryDataList(dictionaryDataListReqDTO);
        BasePageVO<DictionaryDataVo> result = new BasePageVO<>();
        BeanCopyUtil.copyProperties(serviceRes,result);
        return R.ok(result);
    }

    /**
     * 编辑字典数据
     * @param dictionaryDataEditReqDTO 编辑内容
     * @return 主键Id
     */
    @PostMapping("/dictionary_data/edit")
    public R<Long> editData(@RequestBody @Validated DictionaryDataEditReqDTO dictionaryDataEditReqDTO) {
        Long id = dictionaryService.editData(dictionaryDataEditReqDTO);
        return R.ok(id);
    }


    /**
     * 获取某个字典类型下的所有字典数据
     * @param typeKey 字典类型键
     * @return 字典数据列表
     */
    @Override
    public List<DictionaryDataDTO> selectDictDataByType(String typeKey) {
        List<SysDictionaryDataDto> sysDictionaryDataDtos = dictionaryService.selectDictDataByType(typeKey);
        return BeanCopyUtil.copyListProperties(sysDictionaryDataDtos, DictionaryDataDTO::new);
    }



    /**
     * 获取多个字典类型下的所有字典数据
     * @param typeKeys 字典类型键列表
     * @return 字典数据列表
     */
    @Override
    public Map<String, List<DictionaryDataDTO>> selectDictDataByTypeKeys(List<String> typeKeys) {
        Map<String,List<SysDictionaryDataDto>> sysDictionaryDataDtoMap = dictionaryService.selectDictDataByTypeKeys(typeKeys);
        Map<String,List<DictionaryDataDTO>> result = new HashMap<>();
        for (Map.Entry<String, List<SysDictionaryDataDto>> entry : sysDictionaryDataDtoMap.entrySet()) {
            List<SysDictionaryDataDto> sysDictionaryDataDtos = entry.getValue();
            List<DictionaryDataDTO> dictionaryDataDTOS = BeanCopyUtil.copyListProperties(sysDictionaryDataDtos, DictionaryDataDTO::new);
            result.put(entry.getKey(),dictionaryDataDTOS);
        }
        return result;
    }



    /**
     * 根据dataKey获取字典数据
     * @param dataKey 字典数据键
     * @return 字典数据
     */
    @Override
    public DictionaryDataDTO selectDictDataByDataKey(String dataKey) {
        SysDictionaryDataDto selectDictDataByDataKey = dictionaryService.selectDictDataByDataKey(dataKey);
        if(selectDictDataByDataKey != null) {
            DictionaryDataDTO dictionaryDataDTO = new DictionaryDataDTO();
            BeanCopyUtil.copyProperties(selectDictDataByDataKey,dictionaryDataDTO);
            return dictionaryDataDTO;
        }
        return null;
    }


    /**
     * 根据多个dataKey获取字典数据
     * @param dataKeys 字典数据键列表
     * @return 字典数据
     */
    @Override
    public List<DictionaryDataDTO> selectDictDataByDataKeys(List<String> dataKeys) {
        List<SysDictionaryDataDto> sysDictionaryDataDtos = dictionaryService.selectDictDataByDataKeys(dataKeys);
        return BeanCopyUtil.copyListProperties(sysDictionaryDataDtos, DictionaryDataDTO::new);
    }
}
